```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>分布式事务解决方案全解读 | 技术小馆</title>
    <link rel="stylesheet" href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css">
    <link rel="stylesheet" href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.8;
        }
        h1, h2, h3, h4 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 600;
        }
        .hero-bg {
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
        }
        .code-block {
            background-color: #2d3748;
            color: #e2e8f0;
            border-radius: 0.5rem;
        }
        .card-hover {
            transition: all 0.3s ease;
        }
        .card-hover:hover {
            transform: translateY(-5px);
            box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
        }
        .highlight {
            position: relative;
        }
        .highlight:after {
            content: '';
            position: absolute;
            bottom: 0;
            left: 0;
            width: 100%;
            height: 10px;
            background: rgba(118, 75, 162, 0.2);
            z-index: -1;
            transform: scaleX(0);
            transition: transform 0.3s ease;
        }
        .highlight:hover:after {
            transform: scaleX(1);
        }
        .fancy-list li {
            position: relative;
            padding-left: 1.75rem;
            margin-bottom: 0.5rem;
        }
        .fancy-list li:before {
            content: "•";
            position: absolute;
            left: 0;
            color: #667eea;
            font-weight: bold;
        }
    </style>
</head>
<body class="bg-gray-50">
    <!-- Hero Section -->
    <section class="hero-bg text-white py-20 md:py-32 px-4 md:px-0">
        <div class="container mx-auto max-w-5xl px-4">
            <div class="flex flex-col items-center text-center">
                <div class="mb-6">
                    <span class="px-4 py-2 bg-white bg-opacity-20 rounded-full text-sm font-medium">分布式系统专题</span>
                </div>
                <h1 class="text-4xl md:text-5xl font-bold mb-6 leading-tight">分布式事务解决方案全解读</h1>
                <p class="text-xl md:text-2xl text-white text-opacity-90 max-w-3xl mb-10">深入剖析2PC、TCC、Saga等核心模式，构建高可靠分布式系统</p>
                <div class="flex items-center space-x-4">
                    <div class="flex items-center">
                        <i class="far fa-calendar-alt mr-2"></i>
                        <span>2023年11月</span>
                    </div>
                    <div class="flex items-center">
                        <i class="far fa-clock mr-2"></i>
                        <span>阅读时间: 15分钟</span>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <main class="container mx-auto max-w-5xl px-4 py-12 md:py-20">
        <!-- Introduction -->
        <section class="mb-20">
            <div class="prose max-w-none">
                <p class="text-lg md:text-xl text-gray-700 leading-relaxed mb-8">
                    在当今微服务架构盛行的时代，分布式系统的应用越来越广泛。随着系统复杂度的提升，分布式事务的处理成为了一个关键且棘手的问题。分布式事务需要保证在分布式环境下，多个操作要么全部成功提交，要么全部回滚，以此确保数据的一致性。
                </p>
                <div class="my-10 rounded-xl overflow-hidden shadow-lg">
                    <img src="https://cdn.nlark.com/yuque/0/2025/png/21449790/1741096733555-0bf2cf4b-d1af-4bb2-9753-bd7bc78d6e56.png" alt="分布式事务示意图" class="w-full h-auto">
                </div>
            </div>
        </section>

        <!-- Section 1 -->
        <section class="mb-20">
            <h2 class="text-3xl font-bold mb-8 flex items-center">
                <span class="w-8 h-8 bg-blue-600 text-white rounded-full flex items-center justify-center mr-4">1</span>
                <span>分布式事务基础概念</span>
            </h2>
            <div class="prose max-w-none">
                <p>在深入了解具体的分布式事务解决方案之前，先来明确一下分布式事务的基本概念。与传统的单机事务不同，分布式事务涉及到多个不同的服务节点或数据库。例如，在一个电商系统中，下单操作可能涉及到订单服务创建订单、库存服务扣减库存以及支付服务处理支付等多个独立的服务。</p>
                <p>这些服务可能部署在不同的服务器上，甚至使用不同的数据库。为了保证整个下单流程的完整性和数据一致性，就需要引入分布式事务机制，确保所有相关操作要么全部成功，要么全部失败。</p>
            </div>
        </section>

        <!-- Section 2 -->
        <section class="mb-20">
            <h2 class="text-3xl font-bold mb-8 flex items-center">
                <span class="w-8 h-8 bg-purple-600 text-white rounded-full flex items-center justify-center mr-4">2</span>
                <span>两阶段提交（2PC）</span>
            </h2>

            <div class="prose max-w-none">
                <h3 class="text-2xl font-semibold mt-8 mb-4">2PC 原理</h3>
                <p>两阶段提交（Two - Phase Commit，2PC）是一种经典的分布式事务解决方案，它引入了一个协调者（Coordinator）角色来管理事务的提交过程。整个过程分为两个阶段：</p>
                <ul class="fancy-list">
                    <li><strong>准备阶段（Prepare Phase）</strong>：协调者向所有参与者发送事务预提交请求，并等待所有参与者的响应。参与者收到请求后，执行事务操作，但并不提交事务，而是将操作结果反馈给协调者。如果所有参与者都返回成功响应，进入第二阶段；否则，协调者向所有参与者发送回滚请求。</li>
                    <li><strong>提交阶段（Commit Phase）</strong>：若在准备阶段所有参与者都返回成功响应，协调者向所有参与者发送事务提交请求，参与者收到请求后正式提交事务。如果在准备阶段有任何一个参与者返回失败响应，协调者向所有参与者发送事务回滚请求，参与者回滚已执行的事务操作。</li>
                </ul>

                <h3 class="text-2xl font-semibold mt-8 mb-4">2PC 优缺点</h3>
                <div class="grid md:grid-cols-2 gap-6 mb-8">
                    <div class="bg-blue-50 p-6 rounded-xl border border-blue-100">
                        <h4 class="text-lg font-semibold text-blue-800 mb-3 flex items-center">
                            <i class="fas fa-thumbs-up text-blue-600 mr-2"></i>优点
                        </h4>
                        <ul class="space-y-2">
                            <li class="flex items-start">
                                <i class="fas fa-check text-green-500 mt-1 mr-2"></i>
                                <span>实现相对简单，逻辑清晰，易于理解和实现。</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-check text-green-500 mt-1 mr-2"></i>
                                <span>能够保证事务的原子性，确保所有参与者的数据一致性。</span>
                            </li>
                        </ul>
                    </div>
                    <div class="bg-red-50 p-6 rounded-xl border border-red-100">
                        <h4 class="text-lg font-semibold text-red-800 mb-3 flex items-center">
                            <i class="fas fa-thumbs-down text-red-600 mr-2"></i>缺点
                        </h4>
                        <ul class="space-y-2">
                            <li class="flex items-start">
                                <i class="fas fa-times text-red-500 mt-1 mr-2"></i>
                                <span><strong>单点故障</strong>：协调者是整个 2PC 机制的核心，如果协调者出现故障，整个分布式事务将无法正常进行。</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-times text-red-500 mt-1 mr-2"></i>
                                <span><strong>性能问题</strong>：参与者需要等待协调者的指令，期间资源会被锁定，可能导致系统性能下降。</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-times text-red-500 mt-1 mr-2"></i>
                                <span><strong>数据一致性风险</strong>：在提交阶段，如果部分参与者成功提交事务，而部分参与者因网络等原因未能收到提交请求或提交失败，可能会导致数据不一致。</span>
                            </li>
                        </ul>
                    </div>
                </div>

                <h3 class="text-2xl font-semibold mt-8 mb-4">2PC 实战示例</h3>
                <p>以一个简单的转账场景为例，假设存在两个服务：A 服务负责从账户 A 扣款，B 服务负责向账户 B 存款。引入协调者来管理这两个服务的分布式事务。</p>
                <p>在 Java 中，使用 JTA（Java Transaction API）可以实现 2PC。以下是一个简化的代码示例：</p>
                
                <div class="code-block p-4 my-6 rounded-lg overflow-x-auto">
                    <pre><code class="language-java">// 协调者代码示例
import javax.transaction.UserTransaction;
import javax.transaction.TransactionManager;
import javax.naming.InitialContext;
public class Coordinator {
    public static void main(String[] args) {
        try {
            InitialContext context = new InitialContext();
            UserTransaction utx = (UserTransaction) context.lookup("java:comp/UserTransaction");
            TransactionManager tm = (TransactionManager) context.lookup("java:comp/TransactionManager");
            utx.begin();
            // 调用A服务进行扣款操作
            AService aService = new AService();
            aService.debit();
            // 调用B服务进行存款操作
            BService bService = new BService();
            bService.credit();
            utx.commit();
        } catch (Exception e) {
            try {
                utx.rollback();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
            e.printStackTrace();
        }
    }
}
// A服务代码示例
public class AService {
    public void debit() {
        // 模拟从账户A扣款操作
        System.out.println("从账户A扣款");
    }
}
// B服务代码示例
public class BService {
    public void credit() {
        // 模拟向账户B存款操作
        System.out.println("向账户B存款");
    }
}</code></pre>
                </div>
            </div>
        </section>

        <!-- Section 3 -->
        <section class="mb-20">
            <h2 class="text-3xl font-bold mb-8 flex items-center">
                <span class="w-8 h-8 bg-green-600 text-white rounded-full flex items-center justify-center mr-4">3</span>
                <span>补偿事务（TCC）</span>
            </h2>

            <div class="prose max-w-none">
                <h3 class="text-2xl font-semibold mt-8 mb-4">TCC 原理</h3>
                <p>TCC（Try - Confirm - Cancel）模式将事务处理过程分为三个阶段：</p>
                <ul class="fancy-list">
                    <li><strong>Try 阶段</strong>：尝试执行事务，完成所有业务检查（一致性），预留业务资源。例如在转账场景中，Try 阶段 A 服务尝试冻结账户 A 的资金，B 服务尝试预留账户 B 的存款空间。</li>
                    <li><strong>Confirm 阶段</strong>：确认执行事务，在 Try 阶段所有服务都成功的前提下，正式执行事务操作。如 A 服务正式扣除冻结的资金，B 服务正式存入预留的资金。</li>
                    <li><strong>Cancel 阶段</strong>：若 Try 阶段有任何一个服务失败，执行 Cancel 操作，释放 Try 阶段预留的业务资源。如 A 服务解冻冻结的资金，B 服务取消预留的存款空间。</li>
                </ul>

                <h3 class="text-2xl font-semibold mt-8 mb-4">TCC 优缺点</h3>
                <div class="grid md:grid-cols-2 gap-6 mb-8">
                    <div class="bg-blue-50 p-6 rounded-xl border border-blue-100">
                        <h4 class="text-lg font-semibold text-blue-800 mb-3 flex items-center">
                            <i class="fas fa-thumbs-up text-blue-600 mr-2"></i>优点
                        </h4>
                        <ul class="space-y-2">
                            <li class="flex items-start">
                                <i class="fas fa-check text-green-500 mt-1 mr-2"></i>
                                <span>性能较高，相比于 2PC，TCC 减少了资源锁定的时间。</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-check text-green-500 mt-1 mr-2"></i>
                                <span>对网络故障等问题有一定的容错能力，在 Confirm 或 Cancel 阶段如果出现部分失败，可以通过重试机制进行补偿。</span>
                            </li>
                        </ul>
                    </div>
                    <div class="bg-red-50 p-6 rounded-xl border border-red-100">
                        <h4 class="text-lg font-semibold text-red-800 mb-3 flex items-center">
                            <i class="fas fa-thumbs-down text-red-600 mr-2"></i>缺点
                        </h4>
                        <ul class="space-y-2">
                            <li class="flex items-start">
                                <i class="fas fa-times text-red-500 mt-1 mr-2"></i>
                                <span><strong>业务侵入性强</strong>：需要业务代码实现 Try、Confirm 和 Cancel 三个方法，对现有业务代码的改造较大。</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-times text-red-500 mt-1 mr-2"></i>
                                <span><strong>实现复杂度高</strong>：需要处理好重试、幂等性等问题，增加了开发和维护的难度。</span>
                            </li>
                        </ul>
                    </div>
                </div>

                <h3 class="text-2xl font-semibold mt-8 mb-4">TCC 实战示例</h3>
                <p>以 Spring Cloud Alibaba Seata 框架为例，它提供了对 TCC 模式的支持。假设存在一个订单创建并支付的场景，涉及订单服务和支付服务。</p>
                <p>首先定义 TCC 接口：</p>
                
                <div class="code-block p-4 my-6 rounded-lg overflow-x-auto">
                    <pre><code class="language-java">import io.seata.rm.tcc.api.BusinessActionContext;
import io.seata.rm.tcc.api.TwoPhaseBusinessAction;
import org.springframework.stereotype.Service;
@Service
public class OrderTccService {
    @TwoPhaseBusinessAction(name = "createOrderTcc", commitMethod = "commitCreateOrder", rollbackMethod = "rollbackCreateOrder")
    public boolean createOrder(BusinessActionContext context, String orderId, double amount) {
        // Try阶段逻辑，例如检查库存、冻结支付金额等
        System.out.println("尝试创建订单，订单ID：" + orderId + "，金额：" + amount);
        return true;
    }
    public boolean commitCreateOrder(BusinessActionContext context) {
        // Confirm阶段逻辑，例如正式创建订单、扣除支付金额等
        System.out.println("确认创建订单");
        return true;
    }
    public boolean rollbackCreateOrder(BusinessActionContext context) {
        // Cancel阶段逻辑，例如释放冻结金额、恢复库存等
        System.out.println("回滚创建订单");
        return true;
    }
}</code></pre>
                </div>

                <p>在业务代码中调用 TCC 服务：</p>
                
                <div class="code-block p-4 my-6 rounded-lg overflow-x-auto">
                    <pre><code class="language-java">import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class OrderController {
    @Autowired
    private OrderTccService orderTccService;
    @PostMapping("/createOrder")
    public String createOrder(@RequestParam String orderId, @RequestParam double amount) {
        boolean result = orderTccService.createOrder(null, orderId, amount);
        if (result) {
            return "订单创建成功";
        } else {
            return "订单创建失败";
        }
    }
}</code></pre>
                </div>

                <p>通过上述代码，展示了在 Spring Cloud Alibaba Seata 框架下如何实现 TCC 模式的分布式事务。</p>
            </div>
        </section>

        <!-- Section 4 -->
        <section class="mb-20">
            <h2 class="text-3xl font-bold mb-8 flex items-center">
                <span class="w-8 h-8 bg-yellow-600 text-white rounded-full flex items-center justify-center mr-4">4</span>
                <span>Saga 模式</span>
            </h2>

            <div class="prose max-w-none">
                <h3 class="text-2xl font-semibold mt-8 mb-4">Saga 原理</h3>
                <p>Saga 模式是将一个长事务拆分成多个本地短事务，每个本地事务都有对应的补偿事务。当其中某个本地事务失败时，Saga 会按照相反的顺序调用已执行事务的补偿事务，来实现事务的回滚。</p>
                <p>例如在一个电商系统的订单流程中，包含创建订单、扣减库存、处理支付等事务。如果在处理支付时失败，Saga 会依次调用支付的补偿事务（取消支付）、库存的补偿事务（恢复库存）、订单的补偿事务（取消订单）。</p>

                <h3 class="text-2xl font-semibold mt-8 mb-4">Saga 优缺点</h3>
                <div class="grid md:grid-cols-2 gap-6 mb-8">
                    <div class="bg-blue-50 p-6 rounded-xl border border-blue-100">
                        <h4 class="text-lg font-semibold text-blue-800 mb-3 flex items-center">
                            <i class="fas fa-thumbs-up text-blue-600 mr-2"></i>优点
                        </h4>
                        <ul class="space-y-2">
                            <li class="flex items-start">
                                <i class="fas fa-check text-green-500 mt-1 mr-2"></i>
                                <span><strong>业务友好</strong>：对业务代码的侵入性较小，只需要为每个本地事务编写对应的补偿事务即可。</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-check text-green-500 mt-1 mr-2"></i>
                                <span><strong>灵活性高</strong>：适用于业务流程复杂、事务生命周期长的场景，因为它将长事务拆分成多个短事务，降低了事务的复杂性。</span>
                            </li>
                        </ul>
                    </div>
                    <div class="bg-red-50 p-6 rounded-xl border border-red-100">
                        <h4 class="text-lg font-semibold text-red-800 mb-3 flex items-center">
                            <i class="fas fa-thumbs-down text-red-600 mr-2"></i>缺点
                        </h4>
                        <ul class="space-y-2">
                            <li class="flex items-start">
                                <i class="fas fa-times text-red-500 mt-1 mr-2"></i>
                                <span><strong>一致性问题</strong>：在执行过程中，如果某个补偿事务失败，可能会导致数据不一致。</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-times text-red-500 mt-1 mr-2"></i>
                                <span><strong>缺乏全局事务协调</strong>：相比于 2PC 和 TCC，Saga 模式没有一个集中的协调者来管理事务，事务的执行和回滚依赖于各个服务之间的协作，增加了系统的复杂性。</span>
                            </li>
                        </ul>
                    </div>
                </div>

                <h3 class="text-2xl font-semibold mt-8 mb-4">Saga 实战示例</h3>
                <p>在实际项目中，可以使用 Apache Camel 等框架来实现 Saga 模式。假设一个物流系统，订单发货流程涉及订单服务、库存服务和物流服务。</p>
                <p>定义订单服务的 Saga 流程：</p>
                
                <div class="code-block p-4 my-6 rounded-lg overflow-x-auto">
                    <pre><code class="language-java">import org.apache.camel.builder.RouteBuilder;
import org.springframework.stereotype.Component;
@Component
public class OrderSagaRoute extends RouteBuilder {
    @Override
    public void configure() throws Exception {
        from("direct:startOrderSaga")
        .split(body())
        .parallelProcessing()
        .to("direct:createOrder")
        .to("direct:deductInventory")
        .to("direct:sendToLogistics")
        .onException(Exception.class)
        .to("direct:rollbackOrderSaga");
        from("direct:createOrder")
        .log("创建订单")
        .to("bean:orderService?method=createOrder");
        from("direct:deductInventory")
        .log("扣减库存")
        .to("bean:inventoryService?method=deductInventory");
        from("direct:sendToLogistics")
        .log("发送到物流")
        .to("bean:logisticsService?method=sendToLogistics");
        from("direct:rollbackOrderSaga")
        .reverse()
        .to("direct:cancelLogistics")
        .to("direct:restoreInventory")
        .to("direct:cancelOrder");
        from("direct:cancelOrder")
        .log("取消订单")
        .to("bean:orderService?method=cancelOrder");
        from("direct:restoreInventory")
        .log("恢复库存")
        .to("bean:inventoryService?method=restoreInventory");
        from("direct:cancelLogistics")
        .log("取消物流")
        .to("bean:logisticsService?method=cancelLogistics");
    }
}</code></pre>
                </div>
            </div>
        </section>

        <!-- Comparison Section -->
        <section class="mb-20">
            <h2 class="text-3xl font-bold mb-8 flex items-center">
                <span class="w-8 h-8 bg-indigo-600 text-white rounded-full flex items-center justify-center mr-4">5</span>
                <span>2PC、TCC、Saga 对比总结</span>
            </h2>

            <div class="overflow-x-auto">
                <table class="min-w-full divide-y divide-gray-200">
                    <thead class="bg-gray-50">
                        <tr>
                            <th scope="col" class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">对比维度</th>
                            <th scope="col" class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">2PC</th>
                            <th scope="col" class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">TCC</th>
                            <th scope="col" class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Saga</th>
                        </tr>
                    </thead>
                    <tbody class="bg-white divide-y divide-gray-200">
                        <tr>
                            <td class="px-6 py-4 whitespace-nowrap text-sm font-medium text-gray-900">性能</td>
                            <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500">较低，资源锁定时间长</td>
                            <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500">较高，减少资源锁定时间</td>
                            <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500">较高，事务拆分降低锁竞争</td>
                        </tr>
                        <tr>
                            <td class="px-6 py-4 whitespace-nowrap text-sm font-medium text-gray-900">业务侵入性</td>
                            <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500">低，基于 XA 协议，对业务代码改动小</td>
                            <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500">高，需要实现 Try、Confirm、Cancel 方法</td>
                            <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500">中，需要编写补偿事务</td>
                        </tr>
                        <tr>
                            <td class="px-6 py-4 whitespace-nowrap text-sm font-medium text-gray-900">实现复杂度</td>
                            <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500">低，逻辑清晰</td>
                            <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500">高，需处理重试、幂等性等问题</td>
                            <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500">中，事务协调依赖各服务协作</td>
                        </tr>
                        <tr>
                            <td class="px-6 py-4 whitespace-nowrap text-sm font-medium text-gray-900">适用场景</td>
                            <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500">数据一致性要求极高，并发量不高的场景</td>
                            <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500">高并发、高性能要求，业务逻辑可改造场景</td>
                            <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500">业务流程复杂、长事务场景</td>
                        </tr>
                    </tbody>
                </table>
            </div>

            <div class="mt-8 bg-indigo-50 p-6 rounded-xl border border-indigo-100">
                <p class="text-indigo-800 font-medium">
                    <i class="fas fa-lightbulb text-indigo-600 mr-2"></i>
                    在实际项目中，应根据具体的业务需求、系统架构以及性能要求等因素，综合考虑选择合适的分布式事务解决方案。
                </p>
            </div>
        </section>
    </main>

    <!-- Footer -->
    <footer class="bg-gray-900 text-white py-12">
        <div class="container mx-auto max-w-5xl px-4 text-center">
            <div class="flex flex-col items-center">
                <div class="mb-4">
                    <span class="text-xl font-semibold">技术小馆</span>
                </div>
                <div class="mb-6">
                    <a href="http://www.yuque.com/jtostring" class="text-blue-300 hover:text-blue-100 transition-colors duration-200">
                        <i class="fas fa-link mr-2"></i>http://www.yuque.com/jtostring
                    </a>
                </div>
                <div class="text-sm text-gray-400">
                    &copy; 2023 技术小馆. 保留所有权利.
                </div>
            </div>
        </div>
    </footer>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
    </script>
</body>
</html>
```